{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Algorithm DDPG\n",
    "****\n",
    "Randomly initialize critic network $Q(s,a|\\theta^Q)$ and actor $\\mu(s|\\theta^\\mu)$ with weights $\\theta^Q$ and $\\theta^\\mu$<br>\n",
    "initialize target network $Q'$ and $\\mu'$ with weights $\\theta^{Q'}\\leftarrow \\theta^Q, \\theta^{\\mu'} \\leftarrow \\theta^\\mu$<br>\n",
    "Initialize replay buffer $R$<br>\n",
    "**for** episode = 1, M **do**<br>\n",
    "&nbsp;&nbsp;&nbsp;Initialize a random process $N$ for action exploration<br>\n",
    "&nbsp;&nbsp;&nbsp;Receive initial observation state $s_1$<br>\n",
    "&nbsp;&nbsp;&nbsp;**for** t=1, T **do**<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Select action $a_t=\\mu(s_t|\\theta^\\mu)+N_t$ according to the current policy and exploration noise<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Excute action $a_t$ and observe reward $r_t$ and observe new state $s_{t+1}$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Store transition $(s_t,a_t,r_t,s_{t+1})$ in $R$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Sample a random minibatch of $N$ transitions $(s_i,a_i,r_i,s_{i+1})$ from $R$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Set $y_i=r_i+\\gamma Q'(s_{i+1},\\mu'(s_{i+1}|\\theta^{\\mu'})|\\theta^{Q'})$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Update critic by minimizing the loss: $L=\\frac{1}{N}\\sum_i(y_i-Q(s_i,a_i|\\theta^Q))^2$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Update the actor policy using the sampled policy gradient:\n",
    "$$\n",
    "\\nabla_{\\theta^\\mu}J\\approx\\frac{1}{N}\\sum_i\\nabla_aQ(s,a|\\theta^Q)|_{s=s_i,a=\\mu(s_i)}\\nabla_{\\theta^\\mu}\\mu(s|\\theta^\\mu)|s_i\n",
    "$$\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ubdate the target network:\n",
    "$$\n",
    "\\theta^{Q'}\\leftarrow \\tau \\theta^Q +(1-\\tau)\\theta^{Q'}\\\\\n",
    "\\theta^{\\mu'}\\leftarrow \\tau \\theta^\\mu+(1-\\tau)\\theta^{\\mu'}\n",
    "$$\n",
    "&nbsp;&nbsp;&nbsp;**end for**<br>\n",
    "**end for**<br>\n",
    "\n",
    "tips : $\\mu$ 表示确定策略<br>\n",
    "<br>\n",
    "### 代码表示Loss的计算:<br>\n",
    "* #### Critic Loss :\n",
    "$$\n",
    "\\frac{1}{N} \\sum_i \\overbrace{reward+(1.0-done) * gamma * target\\_value\\_net(next\\_state, target\\_policy\\_net(next\\_state))}^{target\\_value}- \\underbrace{value\\_net(state, action)}_{value}\n",
    "$$\n",
    "* #### Policy Loss :\n",
    "$$\n",
    "\\frac{1}{N} \\sum_i value\\_net(state, policy(state))\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 根据上边伪代码整理出以下表格:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><style type=\"text/css\">\n",
    ".tg  {border-collapse:collapse;border-spacing:0;border-color:#bbb;}\n",
    ".tg td{font-family:Arial, sans-serif;font-size:14px;padding:10px 5px;border-style:solid;border-width:0px;overflow:hidden;word-break:normal;border-top-width:1px;border-bottom-width:1px;border-color:#bbb;color:#594F4F;background-color:#E0FFEB;}\n",
    ".tg th{font-family:Arial, sans-serif;font-size:14px;font-weight:normal;padding:10px 5px;border-style:solid;border-width:0px;overflow:hidden;word-break:normal;border-top-width:1px;border-bottom-width:1px;border-color:#bbb;color:#493F3F;background-color:#9DE0AD;}\n",
    ".tg .tg-koh6{font-size:36px;border-color:inherit;text-align:left;vertical-align:top}\n",
    ".tg .tg-7ab7{font-weight:bold;font-size:36px;border-color:inherit;text-align:center;vertical-align:top}\n",
    ".tg .tg-bwtg{font-size:36px;border-color:inherit;text-align:center;vertical-align:top}\n",
    ".tg .tg-n9dp{background-color:#C2FFD6;font-size:36px;border-color:inherit;text-align:left;vertical-align:top}\n",
    "</style>\n",
    "<table class=\"tg\">\n",
    "  <tr>\n",
    "    <th class=\"tg-7ab7\">Algorithm</th>\n",
    "    <th class=\"tg-7ab7\">Neural Network</th>\n",
    "    <th class=\"tg-7ab7\">input</th>\n",
    "    <th class=\"tg-7ab7\">output</th>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-bwtg\" rowspan=\"2\">Critic</td>\n",
    "    <td class=\"tg-n9dp\">target critic network<br>θ^Q'</td>\n",
    "    <td class=\"tg-koh6\">next state s_{i+1} &amp;&amp;<br>the action a_{i+1} of s_{i+1} through θ^𝜇'</td>\n",
    "    <td class=\"tg-n9dp\">Q'(s_{i+1},a_{i+1})<br><big><big>for critic loss</big></big></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-n9dp\">critic network<br>θ^Q</td>\n",
    "    <td class=\"tg-koh6\">current state s_i &amp;&amp;<br>action in current state a_i</td>\n",
    "    <td class=\"tg-n9dp\">Q(s_i,a_i) <br><big><big>for critic loss and <br>policy loss</big></big></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-bwtg\" rowspan=\"2\">Actor</td>\n",
    "    <td class=\"tg-n9dp\">target actor network<br> θ^𝜇'</td>\n",
    "    <td class=\"tg-koh6\">next state s_{i+1}</td>\n",
    "      <td class=\"tg-n9dp\">action a_{i+1} at<br>state s_{i+1}<br><big><big>for critic loss</big></big></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-n9dp\">actor network <br>θ^𝜇</td>\n",
    "    <td class=\"tg-koh6\">current state s_i</td>\n",
    "    <td class=\"tg-n9dp\">𝜇(s_i)<br><big><big> for policy loss</big></big></td>\n",
    "  </tr>\n",
    "</table></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../assets/DDPG_landscape.png\" width=600 />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 特性总结\n",
    "1. 类似于DQN的replay buffer\n",
    "2. 类似于DQN的target network但此处更新的时候采用soft update\n",
    "3. 使用Actor_net输入s&&s'选择动作a&&a'分别用来更新actor_net和Q_net，使用Q_net输入a&&a'分别用来评估(s,a)和(s',a')来更新actor_net和Q_net\n",
    "4. 只能处理连续动作空间，离散动作不存在确定性策略的说法\n",
    "5. 标准化动作空间,对action 增加噪声\n",
    "6. actor-critic思想，但计算loss function的时候和A2C有很大不同<br>\n",
    "    a. A2C里的Critic loss $\\leftrightarrow$ TD error $\\leftrightarrow$ advantage function<br>\n",
    "    因为$\\hat{A}(s,a)=Q(s,a)-V(s)$是TD error的无偏估计。<br>\n",
    "    而DDPG里critic的计算和DoubleDQN很像，只不过计算target_Q的$a_{i+1}$是用网络$\\theta^{\\mu'}$所得的<br>\n",
    "    b.DDPG计算actor loss的时候估计是为了减少计算量，所以使用的是Q(s,a)而不是A(s,a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Tips:\n",
    "**np.clip $\\leftrightarrow$ torch.clamp <br>**\n",
    "$y_i = \\begin{cases}\n",
    "        \\text{min} & \\text{if } x_i < \\text{min} \\\\\n",
    "        x_i & \\text{if } \\text{min} \\leq x_i \\leq \\text{max} \\\\\n",
    "        \\text{max} & \\text{if } x_i > \\text{max}\n",
    "    \\end{cases}$<br>\n",
    "    <br>\n",
    "**torch.detach() , torch.data:<br>**\n",
    "都是将自动微分截断，也就是进行requires_grad=False操作<br>\n",
    "推荐使用detach()，可以对微分进行追踪<br>\n",
    "DDPG这里，将target_Q.detach()保证只更新value_net<br>\n",
    "<br>\n",
    "**Policy_net输出未加F.tanh()**<br>\n",
    "将动作空间控制在-1~+1哇完了<br>\n",
    "tanh公式为:<br>\n",
    "$\\text{Tanh}(x) = \\tanh(x) = \\frac{e^x - e^{-x}}{e^x + e^{-x}}$\n",
    "<img src=\"../assets/TanhReal.gif\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "MountainCarContinuous-v0:感觉该环境可以考虑用HER解决<br>\n",
    "但是我加的噪声是相同的量，就会永远给小车一个向前或者向后的推力,但是这样操作。减少step的话就会没有效果<br>\n",
    "假设这个力是向前的(因为我们最终需要到达对面的山顶)，那么我就可以保持在推力的方向上施加一个向量<br>\n",
    "这个向量有什么作用呢?它可以让我永远是向着目标前进的，即使奖励值很稀疏。但我能sample出十分有用的信息<br>\n",
    "那么问题来了?我要怎么去求这个单位向量，或者说怎么去拟合这个单位向量。nn?<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "import gym\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "from torch.distributions import Normal\n",
    "# from torch.utils.tensorboard import SummaryWriter\n",
    "from IPython.display import clear_output\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns; sns.set(color_codes=True)\n",
    "import pdb\n",
    "%matplotlib inline\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 经验回放\n",
    "class ReplayBuffer:\n",
    "    def __init__(self, column, batch_size, buffer_size):\n",
    "        self.current_state = np.zeros((buffer_size, column), dtype=np.float32)\n",
    "        self.next_state = np.zeros((buffer_size, column), dtype=np.float32)\n",
    "        init = lambda buffer_size : np.zeros(buffer_size, dtype=np.float32)\n",
    "        self.action = init(buffer_size)\n",
    "        self.reward = init(buffer_size)\n",
    "        self.done = init(buffer_size)\n",
    "        self.buffer_size, self.batch_size = buffer_size, batch_size\n",
    "        self.size, self.current_index = 0, 0\n",
    "    \n",
    "    def store(self, current_state, action, next_state, reward, done):\n",
    "        self.current_state[self.current_index] = current_state\n",
    "        self.action[self.current_index] = action\n",
    "        self.next_state[self.current_index] = next_state\n",
    "        self.reward[self.current_index] = reward\n",
    "        self.done[self.current_index] = done\n",
    "        self.current_index = (self.current_index + 1) % buffer_size\n",
    "        self.size = min(self.buffer_size, (self.size + 1))\n",
    "    \n",
    "    def sample(self):\n",
    "        index = np.random.choice(self.size, self.batch_size, replace=False)\n",
    "        return dict(current_state = torch.tensor(self.current_state[index],dtype=torch.float).to(device),\n",
    "                    action = torch.tensor(self.action[index]).reshape(-1, 1).to(device),\n",
    "                    next_state = torch.tensor(self.next_state[index],dtype=torch.float).to(device),\n",
    "                    reward = torch.tensor(self.reward[index]).reshape(-1, 1).to(device),\n",
    "                    done = torch.tensor(self.done[index]).reshape(-1, 1).to(device))\n",
    "    \n",
    "    def __len__(self):\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wrapper 将输入数据进行预处理再输入到env中\n",
    "<img src=\"../assets/gym_wrapper.png\" align=center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "code_folding": [],
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# 对动作空间进行标准化(对输入(_action)输出(_reverse_action)到环境中的action进行标准化)。\n",
    "class NormalizeActions(gym.ActionWrapper):\n",
    "    \n",
    "    def __init__(self, env):\n",
    "        super(NormalizeActions, self).__init__(env)\n",
    "        self.low_bound = self.action_space.low # -2\n",
    "        self.upper_bound = self.action_space.high # +2\n",
    "        \n",
    "    def action(self, action):\n",
    "        # 神经网络使用 tanh 输出的动作在 -1 ~ +1 之间\n",
    "        action = self.low_bound + (action + 1.0) * 0.5 * (self.upper_bound - self.low_bound)\n",
    "        action = np.clip(action, self.low_bound, self.upper_bound)\n",
    "        \n",
    "        return action\n",
    "    \n",
    "    def reverse_action(self, action):\n",
    "        # 对 action 进行反转(reverse)，\n",
    "        action = 2 * (action - self.low_bound) / (self.upper_bound - self.low_bound) - 1\n",
    "        action = np.clip(action, self.low_bound, self.upper_bound)\n",
    "        \n",
    "        return actions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用确定性策略，对action增加噪声\n",
    "class OUNoise:\n",
    "    def __init__(self, action_space, mu=0.0, theta=0.15, max_sigma=0.3, min_sigma=0.1, decay_period=100000):\n",
    "        self.mu = mu\n",
    "        self.theta = theta\n",
    "        self.sigma = max_sigma\n",
    "        self.max_sigma = max_sigma\n",
    "        self.min_sigma = min_sigma\n",
    "        self.decay_period = decay_period\n",
    "        self.action_dim = action_space.shape[0]\n",
    "        self.low = action_space.low\n",
    "        self.high = action_space.high\n",
    "        # get 定义立即执行函数\n",
    "        self.reset()\n",
    "    \n",
    "    def reset(self):\n",
    "        self.state = np.ones(self.action_dim) * self.mu\n",
    "    \n",
    "    def evolve_state(self):\n",
    "        # self.state += [0.0] + 0.3 * np.random.randn(1)\n",
    "        self.state += self.theta * (self.mu - self.state)+np.random.randn(self.action_dim) # *np.sqrt(0.01) * self.sigma\n",
    "        return self.state\n",
    "    \n",
    "    def get_action(self, action, t=0):\n",
    "        # self.sigma = self.max_sigma\n",
    "        self.sigma = self.max_sigma - (self.max_sigma - self.min_sigma) * min(1.0, t / self.decay_period)\n",
    "        return np.clip(action + self.evolve_state(), self.low, self.high)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 两种方式，一种是先训练一层之后再cat。另一种是直接cat\n",
    "class ValueNetwork(nn.Module):\n",
    "    def __init__(self, state_dim, action_dim):\n",
    "        super(ValueNetwork, self).__init__()\n",
    "        self.linear_state = nn.Linear(state_dim, 64)\n",
    "        self.linear_action = nn.Linear(action_dim, 64)\n",
    "        self.linear2 = nn.Linear(128, 32)\n",
    "        self.linear3 = nn.Linear(32, 1)\n",
    "    \n",
    "    def forward(self, state, action):\n",
    "        hidden_state = F.relu(self.linear_state(state))\n",
    "        hidden_action = F.relu(self.linear_action(action))\n",
    "        cat_state_action = torch.cat((hidden_action, hidden_state),dim=1)\n",
    "        hidden2 = F.relu(self.linear2(cat_state_action))\n",
    "        Q = self.linear3(hidden2)\n",
    "        return Q\n",
    "    \n",
    "#     def __init__(self, state_dim, action_dim):\n",
    "#         super(ValueNetwork, self).__init__()\n",
    "#         self.linear1 = nn.Linear(state_dim+action_dim, 256)\n",
    "#         self.linear2 = nn.Linear(256, 256)\n",
    "#         self.linear3 = nn.Linear(256, 1)\n",
    "    \n",
    "#     def forward(self, state, action):\n",
    "#         x = torch.cat((state, action),dim=1)\n",
    "#         x = F.relu(self.linear1(x))\n",
    "#         x = F.relu(self.linear2(x))\n",
    "#         Q = self.linear3(x)\n",
    "#         return Q\n",
    "\n",
    "class PolicyNetwork(nn.Module):\n",
    "    def __init__(self, in_dim, out_dim):\n",
    "        super(PolicyNetwork, self).__init__()\n",
    "        self.linear1 = nn.Linear(in_dim, 256)\n",
    "        self.linear2 = nn.Linear(256, 256)\n",
    "        self.linear3 = nn.Linear(256, out_dim) # (256, 1)\n",
    "    \n",
    "    def forward(self, state):\n",
    "        x = F.relu(self.linear1(state))\n",
    "        x = F.relu(self.linear2(x))\n",
    "        x = torch.tanh(self.linear3(x))\n",
    "        return x\n",
    "    \n",
    "    def get_action(self, state):\n",
    "        state = torch.tensor(state,dtype=torch.float).unsqueeze(0).to(device)\n",
    "        action = self.forward(state)\n",
    "        return action.detach().cpu().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ddpg_train(batch_size, gamma=0.99, soft_tau=1e-2):\n",
    "    samples = replay_buffer.sample()\n",
    "    state, action, next_state = samples['current_state'], samples['action'], samples['next_state']\n",
    "    reward, done = samples['reward'], samples['done']\n",
    "    \n",
    "    target_value = reward + (1.0-done)*gamma*target_value_net(next_state, target_policy_net(next_state))\n",
    "    value = value_net(state, action)\n",
    "    value_loss = ((value - target_value.detach()).pow(2)).mean()\n",
    "    \n",
    "    policy_loss = -value_net(state, policy_net(state)).mean()\n",
    "    \n",
    "    value_optimizer.zero_grad()\n",
    "    value_loss.backward()\n",
    "    value_optimizer.step()\n",
    "    \n",
    "    policy_optimizer.zero_grad()\n",
    "    policy_loss.backward()\n",
    "    policy_optimizer.step()\n",
    "    \n",
    "    for target_param, param in zip(target_value_net.parameters(), value_net.parameters()):\n",
    "        target_param.data.copy_(target_param.data*(1.0-soft_tau) + param.data*soft_tau)\n",
    "    for target_param, param in zip(target_policy_net.parameters(), policy_net.parameters()):\n",
    "        target_param.data.copy_(target_param.data*(1.0-soft_tau) + param.data*soft_tau)\n",
    "    \n",
    "    return value_loss.item(), policy_loss.item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# env = NormalizeActions(gym.make(\"Pendulum-v0\"))\n",
    "env = NormalizeActions(gym.make(\"MountainCarContinuous-v0\"))\n",
    "ou_noise = OUNoise(env.action_space)\n",
    "\n",
    "in_dim = env.observation_space.shape[0] # 3\n",
    "out_dim = env.action_space.shape[0] # 1 连续动作空间\n",
    "\n",
    "value_net = ValueNetwork(in_dim, out_dim).to(device)\n",
    "policy_net = PolicyNetwork(in_dim, out_dim).to(device)\n",
    "\n",
    "target_value_net = ValueNetwork(in_dim, out_dim).to(device)\n",
    "target_policy_net = PolicyNetwork(in_dim, out_dim).to(device)\n",
    "target_value_net.load_state_dict(value_net.state_dict())\n",
    "target_policy_net.load_state_dict(policy_net.state_dict())\n",
    "\n",
    "value_optimizer = optim.Adam(value_net.parameters())\n",
    "policy_optimizer = optim.Adam(policy_net.parameters(), lr=1e-4)\n",
    "\n",
    "buffer_size = 1000000\n",
    "batch_size = 128\n",
    "replay_buffer = ReplayBuffer(in_dim, batch_size, buffer_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "def smooth_plot(factor, item, plot_decay):\n",
    "    item_x = np.arange(len(item))\n",
    "    item_smooth = [np.mean(item[i:i+factor]) if i > factor else np.mean(item[0:i+1])\n",
    "                  for i in range(len(item))]\n",
    "    for i in range(len(item)// plot_decay):\n",
    "        item_x = item_x[::2]\n",
    "        item_smooth = item_smooth[::2]\n",
    "    return item_x, item_smooth\n",
    "    \n",
    "def plot(episode, rewards, value_losses, policy_losses):\n",
    "    clear_output(True)\n",
    "    rewards_x, rewards_smooth = smooth_plot(10, rewards, 500)\n",
    "    value_losses_x, value_losses_smooth = smooth_plot(10, value_losses, 30000)\n",
    "    policy_losses_x, policy_losses_smooth = smooth_plot(10, policy_losses, 30000)\n",
    "    \n",
    "    plt.figure(figsize=(18, 12))\n",
    "    plt.subplot(311)\n",
    "    plt.title('episode %s. reward: %s'%(episode, rewards_smooth[-1]))\n",
    "    plt.plot(rewards, label=\"Rewards\", color='lightsteelblue', linewidth='1')\n",
    "    plt.plot(rewards_x, rewards_smooth, label='Smothed_Rewards', color='darkorange', linewidth='3')\n",
    "    plt.legend(loc='best')\n",
    "    \n",
    "    plt.subplot(312)\n",
    "    plt.title('Value_Losses')\n",
    "    plt.plot(value_losses,label=\"Value_Losses\",color='lightsteelblue',linewidth='1')\n",
    "    plt.plot(value_losses_x, value_losses_smooth, \n",
    "             label=\"Smoothed_Value_Losses\",color='darkorange',linewidth='3')\n",
    "    plt.legend(loc='best')\n",
    "    \n",
    "    plt.subplot(313)\n",
    "    plt.title('Policy_Losses')\n",
    "    plt.plot(policy_losses,label=\"Policy_Losses\",color='lightsteelblue',linewidth='1')\n",
    "    plt.plot(policy_losses_x, policy_losses_smooth, \n",
    "             label=\"Smoothed_Policy_Losses\",color='darkorange',linewidth='3')\n",
    "    plt.legend(loc='best')\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "code_folding": [],
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x864 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-9-95f677a0eb40>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     16\u001b[0m         \u001b[0mreplay_buffer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maction\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnext_state\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreward\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreplay_buffer\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0mbatch_size\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 18\u001b[0;31m             \u001b[0mvalue_loss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpolicy_loss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mddpg_train\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch_size\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     19\u001b[0m             \u001b[0mvalue_losses\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue_loss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     20\u001b[0m             \u001b[0mpolicy_losses\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpolicy_loss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-6-be07af4bbc30>\u001b[0m in \u001b[0;36mddpg_train\u001b[0;34m(batch_size, gamma, soft_tau)\u001b[0m\n\u001b[1;32m     15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m     \u001b[0mpolicy_optimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzero_grad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m     \u001b[0mpolicy_loss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     18\u001b[0m     \u001b[0mpolicy_optimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     19\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/torch/tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph)\u001b[0m\n\u001b[1;32m    105\u001b[0m                 \u001b[0mproducts\u001b[0m\u001b[0;34m.\u001b[0m \u001b[0mDefaults\u001b[0m \u001b[0mto\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    106\u001b[0m         \"\"\"\n\u001b[0;32m--> 107\u001b[0;31m         \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    108\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    109\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mregister_hook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables)\u001b[0m\n\u001b[1;32m     91\u001b[0m     Variable._execution_engine.run_backward(\n\u001b[1;32m     92\u001b[0m         \u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_tensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 93\u001b[0;31m         allow_unreachable=True)  # allow_unreachable flag\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     95\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "episodes = 3000\n",
    "# steps = 1000\n",
    "value_losses = []\n",
    "policy_losses = []\n",
    "all_rewards = []\n",
    "for episode in range(episodes):\n",
    "    state = env.reset()\n",
    "    ou_noise.reset()\n",
    "    episode_reward = 0\n",
    "    for step in range(steps):\n",
    "        action = policy_net.get_action(state)\n",
    "        action = ou_noise.get_action(action, step)\n",
    "        next_state, reward, done, _ = env.step(action.flatten())\n",
    "        \n",
    "        replay_buffer.store(state, action, next_state.flatten(), reward, done)\n",
    "        if len(replay_buffer) > batch_size :\n",
    "            value_loss, policy_loss = ddpg_train(batch_size)\n",
    "            value_losses.append(value_loss)\n",
    "            policy_losses.append(policy_loss)\n",
    "        \n",
    "        state = next_state\n",
    "        episode_reward += reward\n",
    "        \n",
    "        if done:\n",
    "            break\n",
    "    \n",
    "#     soft_loss = lambda loss : np.mean(loss[-100:]) if len(loss)>=100 else np.mean(loss)\n",
    "#     writer.add_scalar(\"Reward\", episode_reward, episode)\n",
    "#     writer.add_scalar(\"Value_Losses\", soft_loss(value_losses), episode)\n",
    "#     writer.add_scalar(\"Policy_Losses\", soft_loss(policy_losses), episode)\n",
    "    \n",
    "    all_rewards.append(episode_reward)\n",
    "    \n",
    "    plot(episode, all_rewards, value_losses, policy_losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# torch.save(policy_net.state_dict(), \"./model/DDPG.pth\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-11-28f95c7e2e51>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     15\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0m_\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1000\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m     \u001b[0mimg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrender\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'rgb_array'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# just update the data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m     \u001b[0mdisplay\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdisplay\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgcf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     18\u001b[0m     \u001b[0mdisplay\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclear_output\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     19\u001b[0m     \u001b[0mpolicy_net\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpolicy_net\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcpu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/IPython/core/display.py\u001b[0m in \u001b[0;36mdisplay\u001b[0;34m(include, exclude, metadata, transient, display_id, *objs, **kwargs)\u001b[0m\n\u001b[1;32m    302\u001b[0m             \u001b[0mpublish_display_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetadata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmetadata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    303\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 304\u001b[0;31m             \u001b[0mformat_dict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmd_dict\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minclude\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minclude\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexclude\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mexclude\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    305\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mformat_dict\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    306\u001b[0m                 \u001b[0;31m# nothing to display (e.g. _ipython_display_ took over)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36mformat\u001b[0;34m(self, obj, include, exclude)\u001b[0m\n\u001b[1;32m    178\u001b[0m             \u001b[0mmd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    179\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 180\u001b[0;31m                 \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mformatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    181\u001b[0m             \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    182\u001b[0m                 \u001b[0;31m# FIXME: log the exception\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m</opt/conda/lib/python3.6/site-packages/decorator.py:decorator-gen-9>\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, obj)\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36mcatch_format_error\u001b[0;34m(method, self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    222\u001b[0m     \u001b[0;34m\"\"\"show traceback on failed format call\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    223\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 224\u001b[0;31m         \u001b[0mr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    225\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    226\u001b[0m         \u001b[0;31m# don't warn on NotImplementedErrors\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m    339\u001b[0m                 \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    340\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 341\u001b[0;31m                 \u001b[0;32mreturn\u001b[0m \u001b[0mprinter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    342\u001b[0m             \u001b[0;31m# Finally look for special method names\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    343\u001b[0m             \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_real_method\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_method\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/IPython/core/pylabtools.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(fig)\u001b[0m\n\u001b[1;32m    242\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    243\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;34m'png'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 244\u001b[0;31m         \u001b[0mpng_formatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfor_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFigure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mprint_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'png'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    245\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;34m'retina'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m'png2x'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    246\u001b[0m         \u001b[0mpng_formatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfor_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFigure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mretina_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/IPython/core/pylabtools.py\u001b[0m in \u001b[0;36mprint_figure\u001b[0;34m(fig, fmt, bbox_inches, **kwargs)\u001b[0m\n\u001b[1;32m    126\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    127\u001b[0m     \u001b[0mbytes_io\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mBytesIO\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 128\u001b[0;31m     \u001b[0mfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbytes_io\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    129\u001b[0m     \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbytes_io\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetvalue\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    130\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mfmt\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'svg'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/matplotlib/backend_bases.py\u001b[0m in \u001b[0;36mprint_figure\u001b[0;34m(self, filename, dpi, facecolor, edgecolor, orientation, format, bbox_inches, **kwargs)\u001b[0m\n\u001b[1;32m   2054\u001b[0m                         \u001b[0morientation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0morientation\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2055\u001b[0m                         \u001b[0mdryrun\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2056\u001b[0;31m                         **kwargs)\n\u001b[0m\u001b[1;32m   2057\u001b[0m                     \u001b[0mrenderer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_cachedRenderer\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2058\u001b[0m                     \u001b[0mbbox_artists\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"bbox_extra_artists\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/matplotlib/backends/backend_agg.py\u001b[0m in \u001b[0;36mprint_png\u001b[0;34m(self, filename_or_obj, metadata, pil_kwargs, *args, **kwargs)\u001b[0m\n\u001b[1;32m    525\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    526\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 527\u001b[0;31m             \u001b[0mFigureCanvasAgg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    528\u001b[0m             \u001b[0mrenderer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_renderer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    529\u001b[0m             \u001b[0;32mwith\u001b[0m \u001b[0mcbook\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_setattr_cm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdpi\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdpi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m\\\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/matplotlib/backends/backend_agg.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    386\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrenderer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_renderer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcleared\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    387\u001b[0m         \u001b[0;32mwith\u001b[0m \u001b[0mRendererAgg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlock\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 388\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    389\u001b[0m             \u001b[0;31m# A GUI class may be need to update a window using this draw, so\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    390\u001b[0m             \u001b[0;31m# don't forget to call the superclass.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m     36\u001b[0m                 \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     37\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 38\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     39\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     40\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0martist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_agg_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/matplotlib/figure.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m   1707\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpatch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1708\u001b[0m             mimage._draw_list_compositing_images(\n\u001b[0;32m-> 1709\u001b[0;31m                 renderer, self, artists, self.suppressComposite)\n\u001b[0m\u001b[1;32m   1710\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1711\u001b[0m             \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose_group\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'figure'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/matplotlib/image.py\u001b[0m in \u001b[0;36m_draw_list_compositing_images\u001b[0;34m(renderer, parent, artists, suppress_composite)\u001b[0m\n\u001b[1;32m    133\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mnot_composite\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhas_images\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    134\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0martists\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 135\u001b[0;31m             \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    136\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    137\u001b[0m         \u001b[0;31m# Composite any adjacent images together\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m     36\u001b[0m                 \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     37\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 38\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     39\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     40\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0martist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_agg_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/matplotlib/axes/_base.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, renderer, inframe)\u001b[0m\n\u001b[1;32m   2643\u001b[0m             \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstop_rasterizing\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2644\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2645\u001b[0;31m         \u001b[0mmimage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_draw_list_compositing_images\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0martists\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2646\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2647\u001b[0m         \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose_group\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'axes'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/matplotlib/image.py\u001b[0m in \u001b[0;36m_draw_list_compositing_images\u001b[0;34m(renderer, parent, artists, suppress_composite)\u001b[0m\n\u001b[1;32m    133\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mnot_composite\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhas_images\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    134\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0martists\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 135\u001b[0;31m             \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    136\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    137\u001b[0m         \u001b[0;31m# Composite any adjacent images together\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m     36\u001b[0m                 \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     37\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 38\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     39\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     40\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0martist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_agg_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/matplotlib/image.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m    617\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    618\u001b[0m             im, l, b, trans = self.make_image(\n\u001b[0;32m--> 619\u001b[0;31m                 renderer, renderer.get_image_magnification())\n\u001b[0m\u001b[1;32m    620\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mim\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    621\u001b[0m                 \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw_image\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ml\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mim\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/matplotlib/image.py\u001b[0m in \u001b[0;36mmake_image\u001b[0;34m(self, renderer, magnification, unsampled)\u001b[0m\n\u001b[1;32m    872\u001b[0m         return self._make_image(\n\u001b[1;32m    873\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_A\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbbox\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtransformed_bbox\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmagnification\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 874\u001b[0;31m             unsampled=unsampled)\n\u001b[0m\u001b[1;32m    875\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    876\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_check_unsampled_image\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/matplotlib/image.py\u001b[0m in \u001b[0;36m_make_image\u001b[0;34m(self, A, in_bbox, out_bbox, clip_bbox, magnification, unsampled, round_to_pixel_border)\u001b[0m\n\u001b[1;32m    510\u001b[0m                     \u001b[0m_interpd_\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_interpolation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    511\u001b[0m                     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_resample\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malpha\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 512\u001b[0;31m                     self.get_filternorm(), self.get_filterrad())\n\u001b[0m\u001b[1;32m    513\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    514\u001b[0m                 \u001b[0;31m#recombine rgb and alpha channels\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# policy_net_1 = PolicyNetwork(in_dim, out_dim)\n",
    "# policy_net_1.load_state_dict(torch.load(\"./model/DDPG.pth\"))\n",
    "# policy_net_1.eval()\n",
    "\n",
    "import pdb\n",
    "import gym\n",
    "from IPython import display\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "env = gym.make(\"MountainCarContinuous-v0\")\n",
    "state = env.reset()\n",
    "img = plt.imshow(env.render(mode='rgb_array')) # only call this once\n",
    "for _ in range(1000):\n",
    "    img.set_data(env.render(mode='rgb_array')) # just update the data\n",
    "    display.display(plt.gcf())\n",
    "    display.clear_output(wait=True)\n",
    "    policy_net = policy_net.cpu()\n",
    "    \n",
    "    action = policy_net(torch.FloatTensor(state)).detach().numpy()\n",
    "    # action = env.action_space.sample()\n",
    "    next_state, _, done, _ = env.step(action)\n",
    "    if done: \n",
    "        state = env.reset()\n",
    "    state = next_state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**发现训练了大概有12个小时还没完，是我的episode设置太多了，从tensorboard的图中看出大概1个小时就训练收敛了<br>\n",
    "中途停了，所以最后没有画出图来，还好tensorboard有记录**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* #### 初次训练的图:\n",
    "<img src=\"../assets/ddpg_first_train.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* #### 未加tanh的训练图:<br>\n",
    "**Reward :**\n",
    "<img src=\"../assets/Reward.png\"><br>\n",
    "**Value_Losses :**\n",
    "<img src=\"../assets/Value_Losses.png\"><br>\n",
    "**Policy_Losses :**\n",
    "<img src=\"../assets/Policy_Losses.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* #### 有加tanh的训练图:<br>\n",
    "**Reward :**\n",
    "<img src=\"../assets/Reward_with_tanh.png\"><br>\n",
    "**Value_Losses :**\n",
    "<img src=\"../assets/Value_Losses_with_tanh.png\"><br>\n",
    "**Policy_Losses :**\n",
    "<img src=\"../assets/Policy_Losses_with_tanh.png\">"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "oldHeight": 691.0904539999999,
   "position": {
    "height": "712.525px",
    "left": "1171.09px",
    "right": "20px",
    "top": "194px",
    "width": "603.05px"
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "varInspector_section_display": "block",
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
